home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / DEMOS / SUN_RSC.ZIP / ZOOM.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-08  |  9.4 KB  |  532 lines
  1. // ZOOM.CPP /////////////////////////////////////////////////////////////////
  2.  
  3. // Thomas H.
  4.  
  5. // INCLUDES /////////////////////////////////////////////////////////////////
  6.  
  7. #include <alloc.h>
  8. #include <stdlib.h>
  9. #include <math.h>
  10. #include <dos.h>
  11. #include "stdio.h"
  12. #include "timer.h"
  13. #include "xgraf.h"
  14. #include "vx.h"
  15. #include "seg.h"
  16.  
  17. // DEFINES  /////////////////////////////////////////////////////////////////
  18.  
  19. #define HITIT        69050
  20. #define MAXFRAMES 1564
  21.  
  22. #define FRAMES    34
  23. #define EXT     192
  24. #define ROUGHSPLITS 12
  25. #define FRACX   0
  26. #define FRACY   0
  27. #define RGBR 3
  28. #define RGBG 2
  29. #define RGBB 6
  30.  
  31. // EXTERNALS ////////////////////////////////////////////////////////////////
  32.  
  33. // FUNCTIONS
  34.  
  35. extern "C" void asmzoom(void);
  36. extern void newhandler(void);
  37.  
  38. // VARS
  39.  
  40. extern ulong musicstart;
  41. extern long far copper_32,
  42.        plustimer;
  43. extern timer_C timer;
  44. extern vx_C vx;
  45. extern byte *pressed,
  46.        rgb[];
  47. extern long far farfrac1, far farfrac2, far fartwist;
  48. extern word far fartune;
  49. extern int far shx,
  50.        far shy,
  51.        far sdx,
  52.        far sdy,
  53.        far khx,
  54.        far khy,
  55.        far kdx,
  56.        far kdy;
  57.  
  58. // VARS /////////////////////////////////////////////////////////////////////
  59.  
  60. word zoomvramptr=0xa000;
  61. static byte *bitdata[FRAMES-1],
  62.        *frac1b,
  63.        *frac2b,
  64.        *frac3b,
  65.        *frac1,
  66.        *frac2,
  67.        *frac3;
  68. word datalengths[FRAMES-1];
  69. word innerlen,
  70.      innerleft,
  71.      innertop,
  72.      innerfac,
  73.      inneradr,
  74.      farfac;
  75. byte startx,
  76.      starty,
  77.      nearstartx,
  78.      nearstarty,
  79.      *globalbmp,
  80.      *datas,
  81.      datamask,
  82.      lastpopped;
  83. int csdata=0;
  84.  
  85. // FUNCTIONS ////////////////////////////////////////////////////////////////
  86.  
  87. // SETZCOLORS
  88.  
  89. void setzcolors(void)
  90. {
  91.     for (int count=1; count<256; count++)
  92.     {
  93.         float r=sin(count*0.5*RGBR*2*M_PI/256);
  94.         float g=sin(count*0.5*RGBG*2*M_PI/256);
  95.         float b=sin(count*0.5*RGBB*2*M_PI/256);
  96.  
  97.         r=fabs(r)*63;
  98.         g=fabs(g)*63;
  99.         b=fabs(b)*63;
  100.  
  101.         vx.setrgb(count,r,g,b);
  102.     }
  103. }
  104.  
  105. // ROUGHSPLIT
  106.  
  107. void roughsplit(byte *from, byte *to,word stripno)
  108. {
  109.     long from_ptr=(long)from;
  110.     long to_ptr=(long)to;
  111.     to_ptr+=256*stripno*(EXT/ROUGHSPLITS);
  112.     from_ptr+=(EXT/4)+(EXT/4)*256+(256*stripno*(EXT/ROUGHSPLITS)/2);
  113.  
  114.     asm pusha
  115.     asm push ds
  116.  
  117.     asm cld
  118.     asm les di,to_ptr
  119.     asm lds si,from_ptr
  120.  
  121.     asm mov bx,es
  122.     asm mov ch,(EXT/ROUGHSPLITS)/2
  123. nextline:
  124.     asm mov cl,EXT/2
  125. nextpixel:
  126.     asm mov al,[si]
  127.     asm inc si
  128.     asm mov ah,al
  129.     asm mov [es:di+256],ax
  130.     asm mov [es:di],ax
  131.     asm inc di
  132.     asm inc di
  133.     asm dec cl
  134.     asm jnz nextpixel
  135.     asm add di,EXT+128
  136.     asm add si,EXT/2+64
  137.     asm dec ch
  138.     asm jnz nextline
  139.     asm pop ds
  140.     asm popa
  141.  
  142. }
  143.  
  144. // POPBIT
  145.  
  146. byte _fastcall popbit(void)
  147. {
  148.     asm les bx,dword ptr datas
  149.     asm mov al,[es:bx]
  150.     asm and al,datamask
  151.     asm shr datamask,1
  152.     asm jnc ok
  153.     asm mov datamask,128
  154.     asm inc word ptr datas
  155. ok:
  156.   return _AL; // Return value already in AL
  157. }
  158.  
  159. // CTEST
  160.  
  161. void near _pascal ctest(int x,int y,byte len)
  162. {
  163. #ifdef NOTUNE
  164.     return;
  165. #endif
  166.     static byte p,fac;
  167.     int yy,xx;
  168.     asm les bx,dword ptr datas
  169.     asm mov yy,2
  170. newx:
  171.     asm mov xx,2
  172. nextx:
  173.     asm les bx,dword ptr datas
  174.     asm mov al,[es:bx]
  175.     asm and al,datamask
  176.     asm shr datamask,1
  177.     asm jnc ok
  178.     asm mov datamask,128
  179.     asm inc word ptr datas
  180. ok:
  181.     asm and al,al
  182.     asm jnz doit
  183.     goto staylow;
  184. doit:
  185.     if (len>2)
  186.     {
  187.         static word nx,ny;
  188.         word len2=len;
  189.         len2>>=1;
  190.         nx=0;
  191.         ny=0;
  192.         if (xx==1)
  193.             nx=len2;
  194.         if (yy==1)
  195.             ny=len2;
  196.         ctest(x+nx,y+ny,len2);
  197.     }
  198.     else
  199.     {
  200.         byte color=0;
  201.         asm les bx,dword ptr datas
  202.         asm mov al,[es:bx]
  203.         asm and al,datamask
  204.         asm shr datamask,1
  205.         asm jnc againok
  206.         asm mov datamask,128
  207.         asm inc word ptr datas
  208. againok:
  209.         asm and al,al
  210.         asm jz notvip
  211.  
  212.             if (popbit())
  213.                 color=1;
  214.             else
  215.                 color=-1;
  216.             goto vipdone;
  217. notvip:
  218.             color=0;
  219.             p=popbit();
  220.             fac=1;
  221.             if (popbit())    color+=fac;    fac<<=1;
  222.             if (popbit())    color+=fac;    fac<<=1;
  223.             if (popbit())    color+=fac;    fac<<=1;
  224.             if (p)
  225.                 color+=2;
  226.             else
  227.             {
  228.                 color+=247;
  229.                 if (color==247)
  230.                 {
  231.                     fac=1;
  232.                     color=0;
  233.                     if (popbit())    color+=fac;    fac<<=1;
  234.                     if (popbit())    color+=fac;    fac<<=1;
  235.                     if (popbit())    color+=fac;    fac<<=1;
  236.                     if (popbit())    color+=fac;    fac<<=1;
  237.                     if (popbit())    color+=fac;    fac<<=1;
  238.                     if (popbit())    color+=fac;    fac<<=1;
  239.                     if (popbit())    color+=fac;    fac<<=1;
  240.                     if (popbit())    color+=fac;    fac<<=1;
  241.                 }
  242.             }
  243. vipdone:
  244.         globalbmp[(x+2-xx)+((y+2-yy)<<8)]+=color;
  245.     }
  246. staylow:
  247.     asm dec xx
  248.     asm jz xdone
  249.     asm jmp nextx
  250. xdone:
  251.     asm dec yy
  252.     asm jz ydone
  253.     asm jmp newx
  254. ydone:
  255. }
  256.  
  257. // FINEMASK
  258.  
  259. void finemask(byte *bits,byte *bmp,word no)
  260. {
  261.     static long bit_ptr;
  262.     bit_ptr=(long)bits;
  263.     if (!no)
  264.         datas=(byte *)bit_ptr;
  265.     globalbmp=bmp;
  266.     datamask=128;
  267.     ctest((no%6)*(EXT/6),(no/6)*(EXT/6),(EXT/6));
  268.     while (datamask<0x80)
  269.     popbit();
  270. }
  271.  
  272. // CONV
  273.  
  274. word conv(int x,int y,int tune)
  275. {
  276.     float fx,fy;
  277.  
  278.     float nearmov=tune/48.0;
  279.     float mov=nearmov/2;
  280.  
  281.     fx=x-FRACX-EXT/2;
  282.     fy=y-FRACY-EXT/2;
  283.     fx/=EXT/2.0;
  284.     fy/=EXT/2.0;
  285.     float fxx=fx*(EXT/2)*(1-mov)+EXT/2;
  286.     float fyy=fy*(EXT/2)*(1-mov)+EXT/2;
  287.  
  288.     int xxx=fxx;
  289.     int yyy=fyy;
  290.     fxx-=xxx;
  291.     fyy-=yyy;
  292.     startx=255.99*fxx;
  293.     starty=255.99*fyy;
  294.     farfac=255.99*(1-mov);
  295.  
  296.     return yyy+EXT*xxx;
  297. }
  298.  
  299. // SETZOOM
  300.  
  301. void setzoom(int zfac)
  302. {
  303.     if (!zfac)
  304.     {
  305.         innerleft=FRACX+EXT/4;
  306.         innertop=FRACY+EXT/4;
  307.         innerlen=EXT/2+1;
  308.         innerfac=255;
  309.         return;
  310.     }
  311.     float mov=zfac/48.0;
  312.     float innerlenf=EXT/(2.0-mov);
  313.     innerlen=innerlenf;
  314.     float realinnerleft=FRACX+EXT/2-innerlen/2;
  315.     float realinnertop=FRACY+EXT/2-innerlen/2;
  316.     innertop=realinnertop;
  317.     innerleft=realinnerleft;
  318.     realinnerleft-=innerleft;
  319.     realinnertop-=innertop;
  320.     nearstartx=0;
  321.     nearstarty=0;
  322.     inneradr=innerleft+80*innertop;
  323.     innerfac=255*(2.0-mov);
  324.     innerfac-=256;
  325. }
  326.  
  327. // DRAWZOOM
  328.  
  329. void drawzoom(long frac2,long frac1,int tune1)
  330. {
  331.     float v=v=M_PI*tune1/96.0;
  332.  
  333.     tune1%=48;
  334.  
  335.     float fac=1.0/(2-tune1/48.0);
  336.  
  337.     float si=sin(v);
  338.     float co=cos(v);
  339.  
  340.     float fdx=-256*si/fac;
  341.     float fdy=256*co/fac;
  342.  
  343.     sdx=fdx;
  344.     sdy=fdy;
  345.     kdx=fdx/2;
  346.     kdy=fdy/2;
  347.  
  348.     shx=(256*96-128)-80*fdy-60*fdx;
  349.     shy=(256*96-128)+80*fdx-60*fdy;
  350.  
  351.     khx=(256*96-128)-40*fdy-30*fdx;
  352.     khy=(256*96-128)+40*fdx-30*fdy;
  353.  
  354.     if (tune1>45)
  355.         tune1=45;
  356.  
  357.     asm pusha
  358.     asm push ds
  359.     farfrac1=frac1;
  360.     farfrac2=frac2;
  361.     fartune=tune1;
  362.     asm mov ax,zoomvramptr
  363.     asm mov es,ax
  364.     asmzoom();
  365.     asm pop ds
  366.     asm popa
  367. }
  368.  
  369. // SETUPZOOMPAGE
  370.  
  371. void setupzoompage(void)
  372. {
  373.     vx.blockfill(0,30000,0);
  374.     vx.blockfill(30000,65535,0);
  375.     vx.setoffset(0);
  376. }
  377.  
  378.  
  379. // ZOOM
  380.  
  381. // frac1=closest, center of picture
  382. // frac2=coming up, closest next time
  383. // frac3=under construction
  384.  
  385. void zoom(void)
  386. {
  387.     outport(0x3d4,0x4309);
  388.  
  389.     seg_C s1(EXT*256l);
  390.     seg_C s2(EXT*256l);
  391.     seg_C s3(EXT*256l);
  392.  
  393.     frac1=s1.ptr;
  394.     frac2=s2.ptr;
  395.     frac3=s3.ptr;
  396.  
  397.     FILE *infile=fopen(FRACTWIST,"rb");
  398.     byte *fa=(byte*)fartwist;
  399.     for (int count=0; count<14720; count++)
  400.     {
  401.         byte temp;
  402.         fread(&temp,1,1,infile);
  403.          *(fa++)=temp;
  404.     }
  405.     fclose(infile);
  406.  
  407.     setupzoompage();
  408.  
  409.     for (word bl=0; bl<EXT*256l; bl++)
  410.         frac1[bl]=frac2[bl]=frac3[bl]=0;
  411.  
  412.     setpalette(ZOOMPAL);
  413.  
  414.     FILE *f3;
  415.     f3=fopen(FRACFILE6,"rb");
  416.     for (int xx=0; xx<192; xx++)
  417.     for (int yy=0; yy<192; yy++)
  418.     {
  419.         byte temp;
  420.         fread(&temp,1,1,f3);
  421.         frac1[xx+256l*yy]=temp;
  422.     }
  423.     fclose(f3);
  424.  
  425.     f3=fopen(FRACFILE7,"rb");
  426.     fread(datalengths,2,FRAMES-1,f3);
  427.     long sum=0;
  428.     long forrigepos;
  429.     FILE *o05=fopen(FRACFILE5,"rb");
  430.     for (int su=0; su<FRAMES-1; su++)
  431.     {
  432.         forrigepos=sum;
  433.         sum+=datalengths[su]+32;
  434.         word len;
  435.         byte *temp;
  436.         if (sum<3l*96l*128l)
  437.         {
  438.             temp=(byte*)(copper_32+forrigepos);
  439.             csdata++;
  440.             len=datalengths[su];
  441.         }
  442.         else
  443.             temp=(byte *)farmalloc((len=datalengths[su])+32);
  444.         if (!temp)
  445.             newhandler();
  446.         fread(temp,1,len,o05);
  447.         bitdata[su]=temp;
  448.     }
  449.     fclose(o05);
  450.     long estart,saalangt;
  451.  
  452.     byte *fixfirst=bitdata[0];
  453.     long left;
  454.     float per;
  455.  
  456.     for (int t=0; t<48; t++)
  457.     {
  458.         if (t<12)
  459.             roughsplit(frac1,frac2,t);
  460.         else
  461.             finemask(fixfirst,frac2,t-12);
  462.     }
  463.  
  464.     long akkurat;
  465.     long fno=0;
  466.  
  467.     float hitto=HITIT;
  468.     for (int runde=0; runde<FRAMES-1; runde++)
  469.     {
  470.         byte *thisjust=bitdata[runde+1];
  471.         for (int tune=0; tune<48; tune++)
  472.         {
  473.             fno++;
  474.             if (tune<12)
  475.                 roughsplit(frac2,frac3,tune);
  476.             else
  477.                 if (runde<FRAMES)
  478.                     finemask(thisjust,frac3,tune-12);
  479.             setzoom(tune);
  480.             if (!(runde+tune))
  481.             {
  482.                 vx.setoffset((zoomvramptr-0xa000+1200)*16);
  483.                 drawzoom((long)frac1,(long)frac2,tune+48*runde);
  484.                 switchpage(0xa000,0xa000+1200,0);
  485.             }
  486.             else
  487.             {
  488.                 if (!runde && tune==1)
  489.                 {
  490.                     long now,gone;
  491.                     do
  492.                     {
  493.                         now=timer.readtimer();
  494.                         gone=timer.elapsed(musicstart,now);
  495.                     } while (gone<HITIT);
  496.                     per=(END_FRACT-HITIT)/((float)MAXFRAMES);
  497.                 }
  498.                 drawzoom((long)frac1,(long)frac2,tune+48*runde);
  499.             }
  500.  
  501.             vx.setoffset((zoomvramptr-0xa000)*16);
  502.             zoomvramptr+=1200;
  503.             if (zoomvramptr==0xa000+3600)
  504.                 zoomvramptr=0xa000;
  505.  
  506.             while ((akkurat=timer.elapsed(musicstart,timer.readtimer()))<hitto);
  507.             hitto+=per;
  508.             if (akkurat>END_FRACT)
  509.             {
  510.                 modex();
  511.                 goto nomore;
  512.             }
  513.             if (fno>=MAXFRAMES)
  514.                 goto nomore;
  515.         }
  516.         byte *temp=frac3;
  517.         frac3=frac1;
  518.         frac1=frac2;
  519.         frac2=temp;
  520.     }
  521.  
  522. nomore:
  523.     for (int fr=0; fr<FRAMES-1; fr++)
  524.     {
  525.         byte *temp=bitdata[fr];
  526.         if(temp && fr>=csdata)
  527.             farfree(temp);
  528.     }
  529.     outport(0x3d4,0x4109);
  530. }
  531.  
  532.